//#include<stdio.h>
//#include<sys/types.h>
//#include<unistd.h>
//#include<stdlib.h>
//
// int main()
//{
//  //while(1)
//  //{
//  //  sleep(1);
//  //}
//  //
//  //while(1)
//  //{
//  //  printf("%d\n", getpid());
//  //  printf("%d\n", getppid());
//  //  sleep(1);
//  //}
//
//  //int ret = fork();
//  //printf("hello proc\n");
//  //sleep(1);
//
//  //pid_t id = fork();
//  ////子进程
//  //if(id == 0)
//  //{
//  //  while(1)
//  //  {
//  //    printf("我是子进程，我的pid是:%d, 我的父进程:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}else{
//  //  //父进程
//  //  while(1)
//  //  {
//  //    printf("我是父进程，我的pid是:%d, 我的父进程:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}
//  //
//
//  //int ret = fork();
//  //printf("hello proc : %d, ret : %d\n", getpid(), ret);
//  //sleep(1);
//
//
//  //pid_t id = fork();
//  ////子进程
//  //if(id == 0)
//  //{
//  //  while(1)
//  //  {
//  //    printf("我是子进程，我的pid:%d, 我的父进程:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}else{
//  //  //父进程
//  //  while(1)
//  //  {
//  //    printf("我是父进程，我的pid:%d, 我的父进程:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}
//
//
//  //while(1)
//  //{
//  //  //printf("我的进程ID: %d\n", getpid());
//  //  //sleep(1);
//  //}
//
//  //pid_t id = fork();
//  //if(id == 0)
//  //{
//  //  int cnt = 5;
//  //  while(cnt)
//  //  {
//  //    printf("我是子进程，我还剩下:%d S\n", cnt--);
//  //    sleep(1);
//  //  }
//  //  printf("我是子进程，我已经僵尸了，等待被检测\n");
//  //  exit(0);
//  //}else{
//  //  while(1)
//  //  {
//  //    sleep(1);
//  //  }
//  //}
//
//  //pid_t id = fork();
//  //if(id == 0)
//  //{
//  //  int cnt = 5;
//  //  while(1)
//  //  {
//  //    printf("我是子进程，我还剩: %d S", cnt--);
//  //    sleep(1);
//  //  }
//  //  printf("我是子进程，我已经僵尸了，等待被检测\n");
//  //  exit(0);
//  //}else{
//  //  int cnt = 3;
//  //  while(cnt)
//  //  {
//  //    printf("我是父进程，我还剩: %d\n", cnt--);
//  //    sleep(1);
//  //  }
//  //  exit(0);
//  //}
//
//
//  //while(1)
//  //{
//  //  //printf("我是进程，我的ID号是: %d\n", getpid());
//  //}
//
//
//
//  //int ret = fork();
//  //printf("hello proc.\n");
//  //sleep(1);
//
//  //pid_t id = fork();
//  //if(id == 0)//子进程
//  //{
//  //  while(1)
//  //  {
//  //    printf("我是子进程，我的pid是: %d, 我的父进程是:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}else{//父进程
//  //  while(1)
//  //  {
//  //    printf("我是父进程，我的pid是: %d, 我的父进程是:%d\n", getpid(), getppid());
//  //    sleep(1);
//  //  }
//  //}
//
//
//  //int ret = fork();
//  //if(ret < 0)
//  //{
//  //  perror("fork");
//  //  return 1;
//  //}
//  //else if(ret == 0)//子进程
//  //{
//  //  printf("我是子进程，我的pid是:%d, ret:%d\n", getpid(), ret);
//  //}
//  //else{//父进程
//  //  printf("我是父进程，我的pid是:%d, ret:%d\n", getpid(), ret);
//  //}
//
//  //sleep(1);
//
//
//
//
//
//  return 0;
//}

//#include<stdio.h>
//
// int main()
//{
//  printf("Hello Linux.\n");
//  return 0;
//}

// #include<stdio.h>

// int main(int argc, char* argv[])
// {
//   for(int i = 0; i < argc; i++)
//   {
//     printf("argv[%d] : %s\n", i, argv[i]);
//   }
//   return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>

// int un_g_val;
// int g_val=100;

// int main(int argc, char *argv[], char *env[])
// {
//    printf("code addr         : %p\n", main);
//    printf("init global addr  : %p\n", &g_val);
//    printf("uninit global addr: %p\n", &un_g_val);
//    char *m1 = (char*)malloc(100);
//    char *m2 = (char*)malloc(100);
//    char *m3 = (char*)malloc(100);
//    char *m4 = (char*)malloc(100);

//    printf("heap addr         : %p\n", m1);
//    printf("heap addr         : %p\n", m2);
//    printf("heap addr         : %p\n", m3);
//    printf("heap addr         : %p\n", m4);

//    printf("stack addr        : %p\n", &m1);
//    printf("stack addr        : %p\n", &m2);
//    printf("stack addr        : %p\n", &m3);
//    printf("stack addr        : %p\n", &m4);
//    //命令行参数
//    for(int i = 0; i < argc; i++)
//    {
//        printf("argv addr         : %p\n", argv[i]); //argv/&argc?
//    }
//    //环境变量
//    for(int i =0 ; env[i];i++)
//    {
//        printf("env addr          : %p\n", env[i]);
//    }
// }

// #include <stdio.h>
// #include <stdlib.h>

// int main(int argc, char *argv[], char *env[])
// {
//    char *m1 = (char*)malloc(100);
//    char *m2 = (char*)malloc(100);
//    char *m3 = (char*)malloc(100);
//    char *m4 = (char*)malloc(100);
//    printf("heap addr         : %p\n", m1);
//    printf("heap addr         : %p\n", m2);
//    printf("heap addr         : %p\n", m3);
//    printf("heap addr         : %p\n", m4);

//    printf("stack addr        : %p\n", &m1);
//    printf("stack addr        : %p\n", &m2);
//    printf("stack addr        : %p\n", &m3);
//    printf("stack addr        : %p\n", &m4);

//    return 0;
// }

// #include<stdio.h>

// int main(int argc, char* argv[], char* env[])
// {
//     int i = 0;
//     for(i = 0; env[i] != NULL; i++)
//     {
//         printf("%s\n", env[i]);
//     }

//     return 0;
// }

// #include<stdio.h>
// #include<stdlib.h>

// int main()
// {

//     printf("%s\n", getenv("PATH"));

//     return 0;
// }

// #include<stdio.h>
// #include<sys/types.h>
// #include<unistd.h>
// #include<stdlib.h>

// int main()
// {
//     while(1)
//     {
//         printf("hello world, pid:%d, ppid:%d, myenv:%s\n", getpid(), getppid(), getenv("test_sl"));
//         sleep(1);
//     }
//     return 0;
// }

// #include<stdio.h>
// #include<sys/types.h>
// #include<unistd.h>

// int g_val = 0;

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         while(1)
//         {
//             printf("我是子进程pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
//             sleep(1);
//         }
//     }else{
//         //父进程
//         while(1)
//         {
//             printf("我是父进程pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
//             sleep(1);
//         }
//     }

//     return 0;
// }

// #include<stdio.h>
// #include<sys/types.h>
// #include<unistd.h>

// int g_val = 0;

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         while(1)
//         {
//             g_val = 100;//子进程修改数据
//             printf("我是子进程, 全局数据我已经修改完了, 请注意查看\n");
//             printf("我是子进程pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
//             sleep(1);
//         }
//     }else{
//         //父进程
//         while(1)
//         {
//             printf("我是父进程pid: %d, ppid: %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
//             sleep(2);
//         }
//     }

//     return 0;
// }

// #include<stdio.h>

// int main()
// {
//     while(1)
//         printf("Hello Linux.\n");

//     return 0;
// }

// #include <stdio.h>
// #include <unistd.h>

// int main()
// {

//     printf("pid : %d\n", getpid());
//     printf("ppid: %d\n", getppid());

//     return 0;
// }

// #include<stdio.h>
// #include<unistd.h>

// int main()
// {
//     int ret = fork();
//     printf("hello proc\n");
//     sleep(1);

//     return 0;
// }


// #include<stdio.h>
// #include<sys/types.h>
// #include<unistd.h>

// int main()
// {
//     pid_t id = fork();//返回值id==0,子进程; >0,父进程
//     if(id == 0)
//     {
//         //子进程
//         while(1)
//         {
//             printf("我是子进程, 我的pid : %d, 我的父进程 : %d\n", getpid(), getppid());
//             sleep(1);
//         }
//     }
//     else
//     {
//         //父进程
//         while(1)
//         {
//             printf("我是父进程, 我的pid : %d, 我的父进程 : %d\n", getpid(), getppid());
//             sleep(1);
//         }
//     }

//     return 0;
// }


// struct cpu_info
// {
//     //速度
//     //核数
//     //频率
//     //runqueue
//     task_struct* queue;
// };

// struct net_div
// {
//     //网卡属性
//     task_struct* wait_queue;
// };


// #include<stdio.h>
// #include<unistd.h>
// #include<sys/types.h>

// int main()
// {
//     while(1)
//     {
//         //printf("%d\n", getpid());
//     }
    
//     return 0;
// }

// #include<stdio.h>
// #include<unistd.h>
// #include<stdlib.h>

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         int cnt = 5;
//         while(cnt)
//         {
//             printf("我是子进程, 我还剩下%d S\n", cnt--);
//             sleep(1);
//         }
//         printf("我是子进程, 我已经僵尸了, 等待被检测\n");
//         exit(0);
//     }
//     else
//     {
//         //父进程
//         while(1)
//         {
//             sleep(1);
//         }
//     }

//     return 0;
// }


// #include<stdio.h>
// #include<unistd.h>
// #include<stdlib.h>

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         while(1)
//         {
//             sleep(1);
//         }
//     }
//     else
//     {
//         //父进程
//         int cnt = 3;
//         while(cnt)
//         {
//             printf("我是父进程, 我还剩下%d S\n", cnt--);
//             sleep(1);
//         }
//         exit(0);
//     }

//     return 0;
// }


// #include<stdio.h>
// #include<unistd.h>
// #include<stdlib.h>

// int main()
// {
//     // pid_t id = fork();
//     // if(id == 0)
//     // {
//     //     //子进程
//     //     while(1)
//     //     {
//     //         sleep(1);
//     //     }
//     // }
//     // else
//     // {
//     //     //父进程
//     //     int cnt = 3;
//     //     while(cnt)
//     //     {
//     //         printf("我是父进程, 我还剩下%d S\n", cnt--);
//     //         sleep(1);
//     //     }
//     //     exit(0);
//     // }

//     while(1){;}

//     return 0;
// }


// #include<stdio.h>
// #include<unistd.h>
// #include<sys/types.h>
// #include<stdlib.h>

// int main()
// {
//     printf("Before: pid is %d\n", getpid());
//     pid_t id = fork();
//     if(id == -1)
//     {
//         perror("fork()");
//         exit(1);
//     }
//     printf("After: pid is %d, fork return %d\n", getpid(), id);
//     sleep(1);

//     return 0;
// }


// #include<stdio.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<unistd.h>

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         while(1)
//         {
//             printf("我是子进程, 我正在运行, 我的pid是: %d\n", getpid());
//             sleep(1);
//         }
//     }
//     else
//     {
//         printf("我是父进程, 我的pid是: %d, 我准备等待子进程啦.\n", getpid());
//         sleep(30);//在30秒之内kill掉子进程, 状态由S变为Z
//         pid_t ret = wait(NULL);//等待成功后, 状态Z消失
//         if(ret < 0)
//         {
//             printf("等待失败.\n");
//         }
//         else
//         {
//             printf("等待成功: result: %d\n", ret);
//         }
//     }
//     return 0;
// }


// #include<stdio.h>
// #include<unistd.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<stdlib.h>

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         int cnt = 5;
//         while(1)
//         {
//             printf("我是子进程, 我正在运行, 我的pid是: %d\n", getpid());
//             sleep(1);
//             cnt--;
//             if(!cnt)
//                 break;
//         }
//         exit(0);
//     }
//     else
//     {
//         //父进程
//         int status = 0;
//         printf("我是父进程: %d, 我准备等待子进程咯\n", getpid());
//         pid_t ret = waitpid(id, &status, 0);//阻塞等待
//         // if(ret > 0)
//         // {
//         //     printf("等待成功, ret: %d, 我所等待的子进程的退出码为: %d\n", ret, (status >> 8) & 0xFF);
//         // }

//         if(ret > 0)//等待成功
//         {
//             if(WIFEXITED(status))//正常退出
//             {
//                 printf("子进程是正常退出的, 退出码为: %d\n", WEXITSTATUS(status));//查看退出码
//             }
//         }
//     }
//     return 0;
// }

// #include<stdio.h>
// #include<unistd.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<stdlib.h>

// int main()
// {
//     pid_t id = fork();
//     if(id == 0)
//     {
//         //子进程
//         while(1)
//         {
//             printf("我是子进程, 我的pid是: %d, 我的ppid是: %d\n", getpid(), getppid());
//             sleep(10);
//             break;
//         }
//         exit(14);
//     }
//     else
//     {
//         //父进程
//         printf("我是父进程, 我的pid是: %d, 我的ppid是: %d\n", getpid(), getppid());
//         sleep(10);
//         int status = 0;
//         pid_t ret = waitpid(id, &status, 0);
//         if(ret > 0)
//         {
//             printf("等待成功, ret: %d, 退出信号: %d, 退出码: %d\n", ret, status & 0x7F, (status >> 8) & 0xFF);
//         }
//         sleep(3);
//     }
//     return 0;
// }


// #include<iostream>
// #include<unistd.h>
// using namespace std;

// int main()
// {
//     //创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }
//     cout << "fd[0]: " << pipefd[0] << endl;
//     cout << "fd[1]: " << pipefd[1] << endl;
//     return 0;
// }

// #include<iostream>
// #include<cstdio>
// #include<unistd.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<cstdlib>
// #include<cstring>
// using namespace std;

// // int main()
// // {
// //     // 1.创建管道
// //     int pipefd[2] = {0};
// //     if(pipe(pipefd) != 0)
// //     {
// //         cerr << "pipe error" << endl;
// //         return 1;
// //     }

// //     // 2.创建子进程
// //     pid_t id = fork();
// //     if(id < 0)
// //     {
// //         cerr << "fork fail" << endl;
// //         return 2;
// //     }
// //     else if(id == 0)
// //     {
// //         // 子进程
// //         // 子进程来进行读取, 子进程就应该关闭写端
// //         close(pipefd[1]);

// //         #define NUM 1024
// //         char buffer[NUM];
// //         while(true)
// //         {
// //             memset(buffer, 0, sizeof(buffer));
// //             ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);
// //             if(s > 0)
// //             {
// //                 // 读取成功
// //                 buffer[s] = '\0';
// //                 cout << "子进程收到消息, 内容是: " << buffer << endl;
// //             }
// //             else if(s == 0)
// //             {
// //                 cout << "父进程写完了, 我也退出啦" << endl;
// //                 break;
// //             }
// //             else
// //             {
// //                 // DO Nothing
// //             }
// //         }
// //         close(pipefd[0]);
// //         exit(0);
// //     }
// //     else
// //     {
// //         // 父进程
// //         // 父进程来进行写入, 就应该关闭读端
// //         close(pipefd[0]);

// //         const char* msg = "你好子进程, 我是父进程, 这次发送的信息编号是: ";
// //         int cnt = 0;
// //         while(cnt < 5)
// //         {
// //             char sendBuffer[1024];
// //             sprintf(sendBuffer, "%s : %d", msg, cnt);// 格式化写入
// //             write(pipefd[1], sendBuffer, strlen(sendBuffer));//不用+1
// //             sleep(1);// 为了现象明显
// //             cnt++;
// //         }
// //         close(pipefd[1]);
// //         cout << "父进程写完了" << endl;
// //     }

// //     pid_t res = waitpid(id, nullptr, 0);
// //     if(res > 0)
// //     {
// //         cout << "等待子进程成功" << endl;
// //     }
    
// //     return 0;
// // }


// int main()
// {
//     //1.创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }

//     //2.创建子进程
//     pid_t id = fork();
//     if(id < 0)
//     {
//         cerr << "fork fail" << endl;
//         return 2;
//     }
//     else if(id == 0)
//     {
//         //子进程
//         //子进程来进行读取, 子进程就应该关闭写端
//         close(pipefd[1]);

//         #define NUM 1024
//         char buffer[NUM];
//         while(true)
//         {
//             memset(buffer, 0, sizeof(buffer));
//             ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);//从文件fd中读,读到buffer中
//             if(s > 0)
//             {
//                 //读取成功
//                 buffer[s] = '\0';
//                 cout << "子进程收到消息, 内容是: " << buffer << endl;
//             }
//             else if(s == 0)
//             {
//                 cout << "父进程写完了, 我也退出啦" << endl;
//                 break;
//             }
//             else
//             {
//                 //Do Nothing
//             }
//         }
//         close(pipefd[0]);
//         exit(0);
//     }
//     else
//     {
//         //父进程
//         //父进程来进行写入, 就应该关闭读端
//         close(pipefd[0]);

//         const char* msg = "你好子进程, 我是父进程, 这次发送的信息编号是: ";
//         int cnt = 0;
//         while(cnt < 5)
//         {
//             char sendBuffer[1024];
//             sprintf(sendBuffer, "%s : %d", msg, cnt);//格式化写入
//             write(pipefd[1], sendBuffer, strlen(sendBuffer));//不用+1
//             sleep(1);//为了现象明显
//             cnt++;
//         }
//         close(pipefd[1]);
//         cout << "父进程写完了" << endl;
//     }
//     pid_t res = waitpid(id, nullptr, 0);
//     if(res > 0)
//     {
//         cout << "等待子进程成功" << endl;
//     }


//     return 0;
// }


// #include<iostream>
// #include<sys/types.h>
// #include<ctime>
// #include<unistd.h>
// #include<cstdlib>
// #include<vector>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<cassert>
// #include<unordered_map>
// using namespace std;

// typedef void(*functor)(); //函数指针
// vector<functor> functors; //方法集合
// unordered_map<uint32_t, string> info;

// void f1()
// {
//     cout << "这是一个处理日志的任务, 执行的进程ID[" << getpid() << "]"
//          << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }
// void f2()
// {
//     cout << "这是一个备份数据的任务, 执行的进程ID[" << getpid() << "]"
//          << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }
// void f3()
// {
//     cout << "这是一个处理网络连接的任务, 执行的进程ID[" << getpid() << "]"
//          << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// //加载任务列表
// void loadFunctor()
// {
//     info.insert({functors.size(), "处理日志的任务"});
//     functors.push_back(f1);

//     info.insert({functors.size(), "备份数据的任务"});
//     functors.push_back(f2);

//     info.insert({functors.size(), "处理网络连接的任务"});
//     functors.push_back(f3);
// }


// int main()
// {
//     //0.加载任务列表
//     loadFunctor();

//     //1.创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }

//     //2.创建子进程
//     pid_t id = fork();
//     if(id < 0)
//     {
//         cerr << "fork fail" << endl;
//         return 2;
//     }
//     else if(id == 0)
//     {
//         //子进程
//         //3.子进程读, 关闭不需要的文件fd
//         close(pipefd[1]);

//         //4.业务处理
//         while(true)
//         {
//             uint32_t operatorType = 0;
//             //如果有数据就读取, 没有数据, 就阻塞等待, 等待任务的到来
//             ssize_t s = read(pipefd[0], &operatorType, sizeof(uint32_t));
//             if(s == 0)
//             {
//                 cout << "我要退出啦, 我是给人打工的, 老板都走了" << endl;
//                 break;
//             }
//             assert(s == sizeof(uint32_t));
//             (void)s;

//             if(operatorType < functors.size())
//                 functors[operatorType]();
//             else
//                 cerr << "bug ? operatorType = " << operatorType << endl; 
//         }
//         close(pipefd[0]);
//         exit(0);
//     }
//     else
//     {
//         //父进程
//         srand(time(nullptr));//生成随机数种子
//         //3.父进程写, 关闭不需要的文件fd
//         close(pipefd[0]);

//         //4.指派任务
//         int num = functors.size();
//         int cnt = 10;
//         while(cnt--)
//         {
//             //5.形成任务码
//             uint32_t commandCode = rand() % num;
//             cout << "父进程指派任务完成, 任务是: " << info[commandCode]<< " 任务的编号是: " << cnt << endl;
//             //向指定的进程下达执行任务的操作
//             write(pipefd[1], &commandCode, sizeof(uint32_t));
//             sleep(1);
//         }
//         close(pipefd[1]);
//         pid_t res = waitpid(id, nullptr, 0);
//         if(res > 0)
//         {
//             cout << "wait success" << endl;
//         }
//     }


//     return 0;
// }


// #include<iostream>
// #include<unistd.h>
// using namespace std;

// int main()
// {
//     //创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }
//     cout << "fd[0] : " << pipefd[0] << endl;
//     cout << "fd[1] : " << pipefd[1] << endl;

//     return 0;

// }


// #include<iostream>
// #include<unistd.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<cstdlib>
// #include<cstdio>
// #include<cstring>
// using namespace std;

// int main()
// {
//     //1.创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }

//     //2.创建子进程
//     pid_t id = fork();
//     if(id < 0)
//     {
//         cerr << "fork error" << endl;
//         return 2;
//     }
//     else if(id == 0)
//     {
//         //child
//         //子进程来进行读取, 就应该关闭写端
//         close(pipefd[1]);

//         #define NUM 1024
//         char buffer[NUM];
//         while(true)
//         {
//             memset(buffer, 0, sizeof(buffer));
//             ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);
//             if(s > 0)
//             {
//                 //读取成功
//                 buffer[s] = '\0';
//                 cout << "子进程收到消息, 内容是: " << buffer << endl;
//             }
//             else if(s == 0)
//             {
//                 cout << "父进程写完了, 我也退出啦" << endl;
//                 break;
//             }
//             else
//             {
//                 // do nothing
//             }
//         }
//         close(pipefd[0]);
//         exit(0);
//     }
//     else
//     {
//         //parent
//         //父进程来进行写入, 就应该关闭读端
//         close(pipefd[0]);

//         const char* msg = "你好子进程, 我是父进程, 这次发送的消息编号是: ";
//         int cnt = 0;
//         while(cnt < 5)
//         {
//             char sendBuffer[1024];
//             sprintf(sendBuffer, "%s : %d", msg, cnt);//格式化写入
//             write(pipefd[1], sendBuffer, strlen(sendBuffer));
//             sleep(1);//为了现象明显
//             cnt++;
//         }
//         close(pipefd[1]);
//         cout << "父进程写完了" << endl;
//     }

//     pid_t res = waitpid(id, nullptr, 0);
//     if(res > 0)
//     {
//         cout << "等待子进程成功" << endl; 
//     }

//     return 0;
// }


// #include<iostream>
// #include<ctime>
// #include<cstdlib>
// #include<cassert>
// #include<vector>
// #include<string>
// #include<unistd.h>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<unordered_map>

// using namespace std;


// typedef void(*functor)();

// vector<functor> functors;//方法集合
// unordered_map<uint32_t, string> info;

// void f1()
// {
//     cout << "这是一个处理日志的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void f2()
// {
//     cout << "这是一个备份数据的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void f3()
// {
//     cout << "这是一个处理网络连接的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void loadFunctor()
// {
//     info.insert({functors.size(), "处理日志的任务"});
//     functors.push_back(f1);

//     info.insert({functors.size(), "备份数据的任务"});
//     functors.push_back(f2);

//     info.insert({functors.size(), "处理网络连接的任务"});
//     functors.push_back(f3);
// }

// int main()
// {
//     //0.加载任务列表
//     loadFunctor();

//     //1.创建管道
//     int pipefd[2] = {0};
//     if(pipe(pipefd) != 0)
//     {
//         cerr << "pipe error" << endl;
//         return 1;
//     }

//     //2.创建子进程
//     pid_t id = fork();
//     if(id < 0)
//     {
//         cerr << "fork error" << endl;
//         return 2;
//     }
//     else if(id == 0)
//     {
//         //child--read
//         //3. 关闭不需要的文件fd
//         close(pipefd[1]);

//         //4.业务处理
//         while(true)
//         {
//             uint32_t operatorType = 0;
//             //如果有数据就读取, 没有数据, 就阻塞等待, 等待数据的到来
//             ssize_t s = read(pipefd[0], &operatorType, sizeof(operatorType));
//             if(s == 0)
//             {
//                 cout << "我要退出啦, 我是给人打工的, 老板都走了" << endl;
//                 break;
//             }
//             assert(s == sizeof(uint32_t));
//             (void)s;

//             if(operatorType < functors.size())
//                 functors[operatorType]();
//             else
//                 cerr << "bug ? operatorType = " << operatorType << endl;
//         }
//         close(pipefd[0]);
//         exit(0);
//     }
//     else
//     {
//         //parent--write
//         //3.关闭不需要的文件fd
// //         close(pipefd[0]);

// //         srand(time(nullptr));//生成随机种子

// //         //4.指派任务
// //         int num = functors.size();
// //         int cnt = 10;
// //         while(cnt--)
// //         {
// //             //5.形成任务码
// //             uint32_t commandCode = rand() % num;
// //             cout << "父进程指派任务完成, 任务是: " << info[commandCode] << "任务的编号是:" << cnt << endl;
// //             //向指定的进程下达执行任务的操作
// //             write(pipefd[1], &commandCode, sizeof(uint32_t));
// //             sleep(1);
// //         }
// //         close(pipefd[1]);
// //         pid_t res = waitpid(id, nullptr, 0);
// //         if(res > 0)
// //         {
// //             cout << "等待子进程成功" << endl;
// //         }

// //     }


// //     return 0;
// // }




// //一个父进程控制一堆子进程 --- 进程池
// #include<iostream>
// #include<unistd.h>
// #include<cassert>
// #include<ctime>
// #include<cstdlib>
// #include<sys/types.h>
// #include<sys/wait.h>
// #include<vector>
// #include<unordered_map>
// using namespace std;


// typedef void(*functor)();

// vector<functor> functors;//方法集合
// unordered_map<uint32_t, string> info;


// void f1()
// {
//     cout << "这是一个处理日志的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void f2()
// {
//     cout << "这是一个备份数据的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void f3()
// {
//     cout << "这是一个处理网络连接的任务, 执行的进程ID[" << getpid() 
//          << "]" << "执行时间是[" << time(nullptr) << "]\n" << endl;
// }

// void loadFunctor()
// {
//     info.insert({functors.size(), "处理日志的任务"});
//     functors.push_back(f1);

//     info.insert({functors.size(), "备份数据的任务"});
//     functors.push_back(f2);

//     info.insert({functors.size(), "处理网络连接的任务"});
//     functors.push_back(f3);
// }

// typedef pair<int32_t/*进程pid*/, int32_t/*该进程对应的管道写端fd*/> elem;
// int processNum = 5;

// void work(int blockfd)
// {
//     cout << "进程[" << getpid() << "]" << "开始工作" << endl; 

//     //子进程核心工作的代码
//     while(true)
//     {
//         //a.阻塞等待 b.获取任务信息
//         uint32_t operatorCode = 0;
//         ssize_t s = read(blockfd, &operatorCode, sizeof(uint32_t));
//         if(s == 0) break;
//         assert(s == sizeof(uint32_t));
//         (void)s;

//         //c.处理任务
//         if(operatorCode < functors.size())
//             functors[operatorCode]();
//     }
//     cout << "进程[" << getpid() << "]" << "结束工作" << endl; 
// }

// void balanceSendTask(const vector<elem>& processFds)
// {
//     srand(time(nullptr));

//     while(true)
//     {
//         sleep(1);
//         //选择一个进程--随机的--负载均衡
//         uint32_t pick = rand() % processFds.size();

//         //选择一个任务
//         uint32_t task = rand() % functors.size();

//         //把任务给一个指定的进程
//         write(processFds[pick].second, &task, sizeof(task));

//         //打印对应的提示信息
//         cout << "父进程指派任务->" << info[task] << "给进程: " << processFds[pick].first
//              << "编号: " << pick << endl;
//     }
// }

// int main()
// {
//     //加载任务列表
//     loadFunctor();

//     vector<elem> assignMap;

//     //创建processNum个进程
//     for(int i = 0; i < processNum; i++)
//     {
//         //定义保存管道fd的对象
//         int pipefd[2] = {0};
        
//         //创建管道
//         pipe(pipefd);

//         //创建子进程
//         pid_t id = fork();
//         if(id == 0)
//         {
//             //child--read
//             close(pipefd[1]);

//             //子进程执行
//             work(pipefd[0]);
//             close(pipefd[0]);
//             exit(0);
//         }

//         //父进程做的事情--write
//         close(pipefd[0]);
//         elem e(id, pipefd[1]);
//         assignMap.push_back(e);
//     }

//     cout << "create all processes success" << endl;
//     //父进程,派发任务
//     balanceSendTask(assignMap);

//     //回收资源
//     for(int i = 0; i < processNum; i++)
//     {
//         if(waitpid(assignMap[i].first, nullptr, 0) > 0)
//         {
//             cout << "wait for: pid = " << assignMap[i].first << "wait success"
//                  << "number: " << i << endl; 
//         }
//         close(assignMap[i].second);
//     }

//     return 0;
// }


#include<iostream>
using std::cout;
using std::endl;

int main()
{
    cout << "Hello Linux" << endl;

    return 0;
}